home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / libcan / canpaint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  4.3 KB  |  226 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  *    candraw -
  19.  *        Draw points, line, rectangles and texture maps onto a 
  20.  *    canvas.
  21.  *
  22.  *                Paul Haeberli - 1991
  23.  *
  24.  *    exports
  25.  *
  26.     void drawaline(c,x,y)
  27.     void drawscatter(c,x,y)
  28.     void drawlongscatter(c,x,y)
  29.     void drawmultiline(c,x,y)
  30.  
  31.     void mysincos(a,s,c)
  32.     void setangle(a)
  33.     void setangledelta(dx,dy)
  34.     void setrectsize(dx,dy)
  35.     void drawarect(c,x,y,tm)
  36.  *
  37.  */
  38. #include "math.h"
  39. #include "canvas.h"
  40. #include "texture.h"
  41.  
  42. float flerp();
  43.  
  44. #define ROTX(x,y)     ((angc*(x))-(angs*(y)))
  45. #define ROTY(x,y)     ((angs*(x))+(angc*(y)))
  46. #define MYTOLERANCE    (0.01)
  47. static float angs, angc;
  48. static float xmin, xmax;
  49. static float ymin, ymax;
  50. static float *costab;
  51.  
  52. void drawaline(c,x,y)
  53. canvas *c;
  54. float x, y;
  55. {
  56.     float x1, y1, x2, y2;
  57.  
  58.     x1 = x+ROTX(xmin,0.0);
  59.     y1 = y+ROTY(xmin,0.0);
  60.     x2 = x+ROTX(xmax,0.0);
  61.     y2 = y+ROTY(xmax,0.0);
  62.     drawaaline(c,x1,y1,x2,y2);
  63. }
  64.  
  65. void drawscatter(c,x,y)
  66. canvas *c;
  67. float x, y;
  68. {
  69.     float dx, dy;
  70.     float x1, y1;
  71.     int i;
  72.  
  73.     for(i=0; i<12; i++) {
  74.     getcircpos(&dx,&dy);
  75.     x1 = x+xmax*dx;
  76.     y1 = y+xmax*dy;
  77.     drawapoint(c,x1,y1);
  78.     }
  79. }
  80.  
  81. void drawlongscatter(c,x,y)
  82. canvas *c;
  83. float x, y;
  84. {
  85.     float dx, dy;
  86.     float rx, ry, x1, y1;
  87.     int i;
  88.  
  89.     dx = 2*xmax;
  90.     dy = dx/15.0;
  91.     for(i=0; i<12; i++) {
  92.     rx = dx*qrand();
  93.     ry = dy*qrand();
  94.     x1 = x+ROTX(rx,ry);
  95.     y1 = y+ROTY(rx,ry);
  96.     drawapoint(c,x1,y1);
  97.     }
  98. }
  99.  
  100. void drawmultiline(c,x,y)
  101. canvas *c;
  102. float x, y;
  103. {
  104.     float x1, y1, x2, y2, fy;
  105.     float oxmin, oxmax;
  106.     int i, nb;
  107.  
  108.     nb = ymax;
  109.     if(nb<2)
  110.        nb = 2;
  111.     for(i=0; i<nb; i++) {
  112.     oxmax = xmax*(1.0+0.4*qrand());
  113.     oxmin = xmin*(1.0+0.2*qrand());
  114.            fy = flerp(ymin,ymax,i/(nb-1.0));
  115.         x1 = x+ROTX(oxmin,fy);
  116.         y1 = y+ROTY(oxmin,fy);
  117.         x2 = x+ROTX(oxmax,fy);
  118.         y2 = y+ROTY(oxmax,fy);
  119.     drawaaline(c,x1,y1,x2,y2);
  120.     }
  121. }
  122.  
  123. void mysincos(a,s,c)
  124. float a;
  125. float *s, *c;
  126. {
  127.     int i;
  128.  
  129.     if(!costab) {
  130.     costab = (float *)mymalloc(360*sizeof(float));
  131.     for(i=0; i<360; i++) 
  132.         costab[i] = fcos((i*M_PI)/180.0);
  133.     }
  134.     while(a<0.0)
  135.        a += 360.0;
  136.     i = a;
  137.     *c = costab[i%360];
  138.     *s = costab[(i+270)%360];
  139. }
  140.  
  141. /*
  142.  *    setangle -
  143.  *        set the angle for brush strokes.
  144.  *
  145.  */
  146. void setangle(a)
  147. float a;
  148. {
  149.     mysincos(a,&angs,&angc);
  150. }
  151.  
  152. /*
  153.  *    setangledelta -
  154.  *        use delx and dely to set the angle for brush strokes.
  155.  *
  156.  */
  157. void setangledelta(dx,dy)
  158. float dx, dy;
  159. {
  160.     float mag;
  161.  
  162.     mag = fsqrt(dx*dx+dy*dy);
  163.     if(mag>0.000001) {
  164.     angc = dx/mag;
  165.     angs = dy/mag;
  166.     }
  167. }
  168.  
  169. /*
  170.  *    setrectsize -
  171.  *        set the size of rectangles.
  172.  *
  173.  */
  174. void setrectsize(dx,dy)
  175. float dx,dy;
  176. {
  177.     xmax = dx/2.0;
  178.     ymax = dy/2.0;
  179.     xmin = -xmax;
  180.     ymin = -ymax;
  181. }
  182.  
  183.  
  184. /*
  185.  *    drawarect -
  186.  *        draw a rectangle at the specified position with the 
  187.  *    current angle, rectsize, color and alpha
  188.  *
  189.  */
  190. void drawarect(c,x,y,tm)
  191. canvas *c;
  192. float x, y;
  193. TEXTURE *tm;
  194. {
  195.     float pos[4][2];
  196.     int i, smini, smaxi;
  197.     float sminy, smaxy;
  198.     float sminx, smaxx, d;
  199.     vect tp, edgex, edgey;
  200.  
  201.     pos[0][0] = x+ROTX(xmin,ymin);
  202.     pos[0][1] = y+ROTY(xmin,ymin);
  203.     pos[1][0] = x+ROTX(xmax,ymin);
  204.     pos[1][1] = y+ROTY(xmax,ymin);
  205.     pos[2][0] = x+ROTX(xmax,ymax);
  206.     pos[2][1] = y+ROTY(xmax,ymax);
  207.     pos[3][0] = x+ROTX(xmin,ymax);
  208.     pos[3][1] = y+ROTY(xmin,ymax);
  209.     if(tm) {
  210.     d = (tm->xsize-1.0-MYTOLERANCE)/(xmax-xmin);
  211.     edgex.x = angc*d;
  212.     edgex.y = angs*d;
  213.     edgex.z = -(pos[0][0]*edgex.x+pos[0][1]*edgex.y);
  214.     d = (tm->ysize-1.0-MYTOLERANCE)/(ymax-ymin);
  215.     edgey.x = -angs*d;
  216.     edgey.y = angc*d;
  217.     edgey.z = -(pos[0][0]*edgey.x+pos[0][1]*edgey.y);
  218.     cantm(tm,&edgex,&edgey);
  219.     } else
  220.     cantm(0,0,0);
  221.     canbeginscan(c,1);
  222.     for(i=0; i<4; i++) 
  223.     canvertex(pos[i][0],pos[i][1]);
  224.     canendscan();
  225. }
  226.